//package com.nt.train.model;
//
//import org.springframework.util.SerializationUtils;
//
//import java.io.*;
//import java.lang.reflect.Constructor;
//import java.lang.reflect.InvocationTargetException;
//import java.util.UUID;
//
///**
// * https://blog.csdn.net/wlm123565/article/details/122946330
// * https://www.jb51.net/article/237738.htm
// * https://blog.csdn.net/qq_45722267/article/details/123776307
// *1.通过new xxx()调用构造方法创建对象
// 2.通过反射创建对象
// 3.通过反射，调用construct.newInstance()创建对象
// 4.通过xxx.clone()克隆的方式创建对象
// 5.通过序列化、反序列化创建对象
// * @author hlf
// * @version 1.0
// * @date 2022/8/15 15:25
// *  使用 new 关键字调用对象的构造器；
//    使用 Java 反射的 newInstance() 方法；
//    使用 Object 类的 clone() 方法；
//    使用对象流 ObjectInputStream的readObject()方法读取序列化对象；
// */
//public class TestCreateObject {
//
//    //1.通过new xxx()调用构造方法创建对象
//    private static Student creatNewStudent(){
//        return new Student(UUID.randomUUID().toString(),"丁强");
//    }
//
//    //2.通过xxx.clone()克隆的方式创建对象
//    private static Student createCloneStudent(){
//        Student studentOne = new Student(UUID.randomUUID().toString(),"吴雨");
//        try {
//            return (Student) studentOne.clone();
//        } catch (CloneNotSupportedException e) {
//            e.printStackTrace();
//        }
//        return null;
//    }
//
//    //3、通过反射创建对象 【类派发一个对象（反射）】
//    private static Student createClassStudent(){
//        try {
//            Student student = Student.class.newInstance();
//            //得到一个空的对象
//            student.setId(UUID.randomUUID().toString());
//            student.setName("雷超");
//            return student;
//        } catch (InstantiationException e) {
//            e.printStackTrace();
//        } catch (IllegalAccessException e) {
//            e.printStackTrace();
//        }
//        return null;
//    }
//
//    //3、通过反射创建对象 【动态加载一个对象（反射）】
//    private static Student createClassStudent2(){
//        try {
//            Student student = (Student) Class.forName("com.nt.train.model.Student").newInstance();
//            //得到一个空的对象
//            student.setId(UUID.randomUUID().toString());
//            student.setName("雷超2");
//            return student;
//        } catch (IllegalAccessException e) {
//            e.printStackTrace();
//        } catch (InstantiationException e) {
//            e.printStackTrace();
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        }
//        return null;
//    }
//
//
//
//    //4.通过反射，调用construct.newInstance()创建对象 【构造一个对象（反射）】
//    private static Student createConstructStudent(){
//        //获取Student类对应的CLASS字节码对象
//        Class<Student> studentClass = Student.class;
//        //获取Student类中有参构造方法
//        try {
//            Constructor<Student> constructor = studentClass.getConstructor(String.class,String.class);
//            return constructor.newInstance(UUID.randomUUID().toString(),"马申");
//        } catch (NoSuchMethodException e) {
//            e.printStackTrace();
//        } catch (InvocationTargetException e) {
//            e.printStackTrace();
//        } catch (InstantiationException e) {
//            e.printStackTrace();
//        } catch (IllegalAccessException e) {
//            e.printStackTrace();
//        }
//        return null;
//    }
//
//
//
//
//    //5.通过序列化、反序列化创建对象
//    private static Student createSerializableStudent(){
//        Student student = new Student(UUID.randomUUID().toString(),"李四");
//        //将student对象序列化到student.txt文件中
//        try {
//            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("G:\\student.txt"));
//            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("G:\\student.txt"));
//            oos.writeObject(student);
//            //从student.txt文件中反序列化出student对象
//            return (Student) ois.readObject();
//        } catch (IOException e) {
//            e.printStackTrace();
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        }
//        return null;
//    }
//
//    public static void main(String[] args) {
//        System.out.println("第一种【调用构造方法】" + creatNewStudent());
//        System.out.println("第二种【克隆的方式创建对象】" + createCloneStudent());
//        System.out.println("第三种【通过反射创建对象 【类派发一个对象（反射）】】" + createClassStudent());
//        System.out.println("第三种【通过反射创建对象 【动态加载一个对象（反射）】】" + createClassStudent2());
//        System.out.println("第四种【构造一个对象（反射）】" + createConstructStudent());
//        //  System.out.println("第五种方法"+createSerializableStudent());
//
//        //当我们序列化和反序列化一个对象，JVM会给我们创建一个单独的对象，在反序列化时，JVM创建对象并不会调用任何构造函数。
//        // 为了反序列化一个对象，我们需要让我们的类实现Serializable接口。
//        Student student = new Student("0001", "武汉");
//        byte[] bytes = SerializationUtils.serialize(student);
//
//        // 字节数组：可以来自网络、可以来自文件（本处直接本地模拟）
//        Object deserCity = SerializationUtils.deserialize(bytes);
//        System.out.println(student);
//        System.out.println(deserCity);
//        System.out.println(student == deserCity);
//    }
//
//}
